package TIP.方法;

public class text {
}

/*
*一.方法基础概念
什么是方法

Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段
为什么要声明方法

（方法的好处）
①把复用的逻辑抽取出来，封装成方法，提高代码的重用性
②实现相对独立的逻辑，提高代码的维护性
③可以对具体实现进行隐藏、封装
方法的作用

简化代码，提高代码的可读性，可维护性，可重用性
方法的声明格式

语法：
访问权限修饰符 其他修饰符 返回值类型 方法名称(参数列表) {
 //方法体【函数体】 return 返回值；
 //如果返回值类型void ,可以不用写return
 }
1
2
3
4
不写默认是default
如图是修饰符的访问权限
修饰符	当前类	相同包	子类	其他包
public	√	√	√	√
protetcted	√	√	√	×
default	√	√	×	×
private	√	×	×	×
Java访问修饰符包括private，default，protected和public。含义分别表示私有的，默认的，受保护的和公有的访问修饰符。这些访问修饰符既可以修饰类中的属性，又可以修饰类中的方法，而public和default还可以修饰类。在同一个java文件里，公有类有且仅有一个，并且该文件命名为类名.java。

二.方法的分类
根据方法有没有参数,可分为:
1.无参方法
2.有参方法
根据有没有返回值，可分为：
1.无返回值方法
2.有返回值方法
* public class Demo{

//  1. 最简单的无参方法
    void sum1(){
        System.out.println("加法操作");
    }
//    2. 拥有修饰符的无参方法
    public static void sum2(){
        System.out.println("加法操作");
    }
//    3. 拥有参数的方法
    public static void sum3(int a,int b){
        System.out.println("两数相加结果"+a+b);
    }
//    4.拥有返回值的方法
    public static int sum4(int a,int b){

        return a+b;
    }
//        5.声明一个无参数带返回值

    public static int sum5(){
        int x=20;
        int y=28;
        int z=x+y;
        return z;
    }
}
三.方法的调用格式
语法：方法名称(实参列表);
注意：
a.实参的数量和类型必须和形参保持完全的一致。
b.方法之间只能进行相互的调用，而不能在方法中声明方法，就目前而言声明的方法都和main方法时并列的
c.如果定义方法有返回值，运算的结果会返回给调用者，调用者需要定义变量接收数据
无返回值的调用格式案例
*public class Demo{

    public static void main(String[] args) {
        //实参
        int a = 10;
        int b = 20;
        swap(a,b);

        System.out.println("main函数中的a=" + a);//10
        System.out.println("main函数中的b=" + b);//20
    }
    //分析：需要参数（两个参数）
    // 不需要返回值
    // 形参：没有携带值的变量，多个变量之间使用逗号分隔

    public static void swap(int a,int b){
        int temp = 0;
        temp = a;
        a = b ;
        b = temp ;

        System.out.println("swap函数中的a=" + a); //20
        System.out.println("swap函数中的b=" + b); //10
    }
}
swap函数中的a=20
swap函数中的b=10
main函数中的a=10
main函数中的b=20
初学者一定要理解好形式参数和实际参数
有方法的返回值的案例

有返回值的要用到return关键字
return关键字的作用：结束方法,返回结果，
情况1public class Demo {

    public static void main(String[] args) {
        show();
    }

    /*1>在没有返回值的函数中使用return
    return单独成立一条语句，
    类似于break或者continue，后面不能跟任何的数值
    作用：结束整个方法 */
//public static void show() {
//    System.out.println("Hello World!");
//    int x = 10;
//    if (x > 5) {
//        return;//结束方法 }
//    }
//    // 不能执行
//    System.out.println("Hello World!========");
//}
//}
//
//Hello World!

/*
情况2public class Demo {

    public static void main(String[] args) {
       int result = add(10,20);
       System.out.println(result);
    }

    /*2>在一个有返回值的函数中使用return
    这种情况下函数中必须出现return
    return后面必须跟一个具体的数值，而且数值的类型和返回值类型必须保持一致
    作用：结束整个方法，并且将返回值携带给调用者 */
//public static int add(int a ,int b) {
//    System.out.println("Hello World!");
//    int c = a+b;
//    return c;
//}
//}
//30

//   情况3public class Demo {

   /* public static void main(String[] args) {
        int result = compare(34,67);
        System.out.println(result);
    }

    *//*3>如果一个自定义的函数有返回值，
    并且在方法中遇到了分支结构，使用return
     在每一个分支后面都需要出现一个return *//*//

    // 需求：比较两个变量的大小，返回较大的一个
    public static int compare(int a,int b) {
        if(a>b){
            return a;
        }
        else if(a<b){
            return b;
        }
        else{
            return 0;
        }
    }
}*/
/*
67
        四.方法的重载
        方法重载的概念

        同一个类中，方法名字相同，参数列表不同，则是方法重载。
        注意：
        参数列表的不同包括，参数个数不同，参数数据类型不同，参数顺序不同
        方法的重载与方法的修饰符和返回值没有任何关系public class Demo {
*/

// public static void main(String[] args) {
     /*   show();
        show(10);
        show("10");
        show("10",10);
    }

    public static void show() {
        System.out.println("无参无返回值的show");
    }

    public static void show(int a) {
        System.out.println("int的show");
    }

    public static void show(String a) {
        System.out.println("String的show");
    }

    public static void show(String a,int b) {
        System.out.println("String int的show");
    }

}*/
    /*无参无返回值的show
            int的show*/
/*String的show
        String int的show
        以上的就代表JAVA方法的重载
        五.拓展
        区分什么是类方法和实例方法

        类方法：
        使用static修饰的方法，是属于当前整个类的，而不是属于某个实例的，只能处理static域或调用static方法。
        实例方法：
        属于对象的方法，有对象来调用。*/
/*public class Demo {

    float a;
    //实例方法
    void sum(float num1,float num2){
        a = Max(num1,num2);
    }

    //类方法
    static  float Max(float num1,float num2){
        //取最大值
        return num1 <= num2 ? num2 :num1;
    }

    public static void main(String[] args) {
        Demo demo =new Demo();
        demo.sum(22,33);  //实例方法必需先初始化类的实例，然后通过类的实例才能调用
        Demo.Max(12,9);   // 类方法可以直接通过类名调用

    }

}*/

/*
一个类中的方法可以互相调用。但要注意：实例方法可以调用该类中的其他方法，例如，sum()可以调用Max()。类方法只能调用其他类方法，不能调用实例方法。
        类方法又叫静态方法， 实例方法又叫非静态方法。
        类方法可以直接通过类名调用，实例方法必需先初始化类的实例，然后通过类的实例才能调用
        知识点小结
        Java中的方法分为类方法和实例方法，区别是类方法中有static修饰，为静态方法，是类的方法。所以在类文件加载到内存时就已经创建，但是实例方法是对象的方法，
        只有对象创建后才起作用，所以在类方法中不能调用实例方法，但实例方法中可以调用类方法，且实例方法可以互相调用。

*/
